import type {
  EntityApi,
  EntityReq,
  EntityModel,
  EntityTotal,
  EntityExportReq,
  EntityImportReq
} from "../api/types";
import { ref, reactive } from "vue";
import type { Ref } from "vue";
import { ElMessageBox, ElMessage } from "element-plus";
import { saveAs } from "file-saver";
import { useListStore } from "@/stores/modules/searchCondition";

/** use table hooks */
export function useTableHooks(t: any, api: EntityApi, query: Ref<EntityReq>) {
  const tableHooks = new TableHooks(t, api, query);
  // table挂载的实例
  const multipleTableRef: Ref<any> = tableHooks.multipleTableRef;
  // 表单挂载的实例
  const queryFormRef: Ref<any> = tableHooks.queryFormRef;

  // 列表加载
  const listLoading: Ref<boolean> = tableHooks.listLoading;
  // 获取列表的数据
  const tableData: Ref<EntityModel[]> = tableHooks.tableData;
  // 总条数
  const total: Ref<number> = tableHooks.total;

  return { tableHooks, multipleTableRef, queryFormRef, listLoading, tableData, total };
}

/** 表格Hooks */
export class TableHooks {
  // table挂载的实例
  multipleTableRef = ref();
  // 表单挂载的实例
  queryFormRef = ref();
  // 列表加载
  listLoading: Ref<boolean> = ref(false);
  //获取列表的数据
  tableData: Ref<EntityModel[]> = ref([] as EntityModel[]);
  // 总条数
  total: Ref<number> = ref(0);
  // 列表统计条数
  totalRecord: Ref<EntityTotal> = ref({} as EntityTotal);
  //选择的行
  selectionRows: Ref<EntityModel[]> = ref([] as EntityModel[]);
  // 查询的参数
  queryData: Ref<EntityReq>;
  //api
  api: EntityApi;
  //useI18n
  t: any;

  //构造函数
  constructor(t: any, api: EntityApi, query: Ref<EntityReq>) {
    this.t = t;
    this.api = api;
    this.queryData = query;
  }

  /** 获取Page/List列表数据. */
  getList() {
    if (this.api.findPage) {
      this.findPage();
    } else {
      this.findList();
    }
  }
  //查询列表数据.
  findList() {
    // 检查变量是否定义
    if (typeof this.api.findList === "undefined") {
      console.error(" api.findList is not undefined.");
      return false;
    }
    // 设置加载状态为true
    this.listLoading.value = true;
    // 调用api的list方法，并传入queryData参数
    this.api
      .findList(this.queryData.value)
      .then(({ data }) => {
        // 检查返回的数据是否有效
        if (!data || typeof data !== "object") {
          console.error("Invalid data received.");
          this.listLoading.value = false;
          return;
        }
        // 将返回的数据中的results赋值给tableData
        this.tableData.value = data.results;
        // 设置加载状态为false
        this.listLoading.value = false;
      })
      .catch((error) => {
        // 捕获错误并打印错误信息
        console.error("An error occurred:", error);
        this.listLoading.value = false;
      });
    return true;
  }

  findPage() {
    // 检查变量是否定义
    if (typeof this.api.findPage === "undefined") {
      console.error(" api.findPage is not undefined.");
      return false;
    }
    // 设置加载状态为true
    this.listLoading.value = true;
    // 调用api的list方法，并传入queryData参数
    this.api
      .findPage(this.queryData.value)
      .then(({ data }) => {
        // 检查返回的数据是否有效
        if (!data || typeof data !== "object") {
          console.error("Invalid data received.");
          this.listLoading.value = false;
          return;
        }
        // 将返回的数据中的results赋值给tableData
        this.tableData.value = data.results;
        // 设置加载状态为false
        this.listLoading.value = false;
        // 将返回的数据中的totalSize赋值给total
        this.total.value = data.totalSize;
        if (data.totalDto) this.totalRecord.value = data.totalDto;
      })
      .catch((error) => {
        // 捕获错误并打印错误信息
        console.error("An error occurred:", error);
        this.listLoading.value = false;
      });
    return true;
  }

  /** 处理查询,如果查询数据中存在当前页数，则重置为第一页. */
  handleQuery() {
    if (this.queryData.value.curPage) {
      this.queryData.value.curPage = 1;
    }
    this.getList();
  }

  //列排序.
  handleSort(prop: string, order: string | null) {
    if (order == null) {
      delete this.queryData.value.orderName;
      delete this.queryData.value.orderAsc;
    } else {
      this.queryData.value.orderName = prop;
      this.queryData.value.orderAsc = order == "ascending";
    }
    this.getList();
  }

  // 重置
  resetQuery() {
    this.queryFormRef.value.resetFields();
    this.handleQuery();
  }

  /** 从详情页返回列表页并保留查询条件重新查询 */
  restoreAndQuery() {
    console.log(this.queryData.value);
    if (this.queryData.value.curPage) {
      this.queryData.value.curPage = 1;
    }

    // 使用列表存储来设置新的查询参数，确保其他组件可以共享这些参数
    useListStore().setQueryParams(this.queryData.value);
    this.getList();
  }

  /**
   * 用于清除查询条件并重新加载数据与restoreAndQuery（）对应
   * 此函数用于重置查询表单，清除查询参数，并触发数据的重新加载
   * @param {Array<string>} key - 需要重置的查询参数键数组
   */
  clearQueryAndReload(key?: Array<string>) {
    console.log(this.queryFormRef);
    // 重置查询表单的字段
    this.queryFormRef.value.resetFields();
    // 重置列表组件的查询参数
    useListStore().resetQueryParams(key);
    console.log(useListStore().queryParams);
    // 执行恢复查询状态并重新查询的方法
    this.restoreAndQuery();
  }

  /** 删除记录 */
  deleteRecord(row: EntityModel) {
    const key = this.api.getKey(row);
    // 弹出一个确认框，询问用户是否确定删除记录
    ElMessageBox.confirm(this.t("common.confirmDelete"), this.t("common.delete"), {
      // 取消按钮的文本
      cancelButtonText: this.t("common.cancel"),
      // 确认按钮的文本
      confirmButtonText: this.t("common.confirm"),
      // 确认框的类型为警告
      type: "warning"
      // 当用户点击确认按钮时，执行删除操作
    })
      .then(() => {
        // 检查变量是否定义
        if (typeof this.api.delete === "undefined") {
          console.error(" api.delete is not undefined.");
          return;
        }
        // 调用 api 的 del 方法删除记录，并传入 id 作为参数
        this.api.delete(key).then((response) => {
          // 如果响应的状态码为 200，表示删除成功
          if (response.status === 200) {
            // 显示删除成功的消息
            ElMessage({
              message: this.t("common.deleteSuccess"),
              type: "success"
            });
            // 调用 getList 方法查询数据
            this.getList();
          }
        });
        // 当用户点击取消按钮或取消框时，执行以下代码块
      })
      .catch((error) => {
        // 处理错误，并给用户反馈
        // 在开发环境中可以保留，但在生产环境中应考虑移除或替换为更安全的日志记录方式
        console.error("Deletion failed:", error);
      });
  }

  /** 删除多项记录 */
  deleteRecords() {
    // 判断选择行是否为空
    if (this.selectionRows.value.length === 0) {
      // 显示提示信息
      ElMessage({
        message: this.t("common.chooseDelete"),
        type: "warning"
      });
      return;
    }

    // 将选择行的 id 提取出来并保存到 ids 数组中
    const ids = this.selectionRows.value.map((item) => this.api.getKey(item));
    console.log(ids);

    // 显示确认删除的弹窗
    ElMessageBox.confirm(this.t("common.confirmBatchDelete"), this.t("common.delete"), {
      cancelButtonText: this.t("common.cancel"),
      confirmButtonText: this.t("common.confirm"),
      type: "warning"
    })
      .then(() => {
        // 检查变量是否定义
        if (typeof this.api.batchDelete === "undefined") {
          console.error(" api.batchDelete is not undefined.");
          return;
        }
        // 调用 api.dels 方法批量删除记录，并返回响应结果
        this.api.batchDelete(ids).then((response) => {
          // 如果响应状态码为 200，则显示删除成功的提示信息，并调用 handleQuery 方法查询数据
          if (response.status === 200) {
            ElMessage({
              message: this.t("common.successDelete") + response.data + this.t("common.stripData"),
              type: "success"
            });
            this.getList();
            //清空用户的选择
            this.multipleTableRef.value?.clearSelection();
          }
        });
      })
      .catch((error) => {
        // 处理错误，并给用户反馈
        // 在开发环境中可以保留，但在生产环境中应考虑移除或替换为更安全的日志记录方式
        console.error("Deletion failed:", error);
      });
  }
  // 上移/下移
  handleMove(row: EntityModel, up: boolean) {
    // 检查变量是否定义
    if (typeof this.api.move === "undefined") {
      console.error(" api.move is not undefined.");
      return;
    }
    const key = this.api.getKey(row);
    // 调用 api.down 方法，传入 id 作为参数
    this.api.move(key, up).then((response) => {
      // 检查响应是否有效
      if (!response || typeof response !== "object") {
        console.error("Invalid response from api.down()");
        return;
      }
      // 如果返回的状态码为 200
      if (response.status === 200) {
        // 调用 getList 方法
        this.getList();
      }
    });
  }
  //启用/禁用
  enableRecord(row: EntityModel, enabled: boolean) {
    // 检查变量是否定义
    if (typeof this.api.enable === "undefined") {
      console.error(" api.enable is not undefined.");
      return;
    }
    const key = this.api.getKey(row);
    this.api.enable(key, enabled).then((response) => {
      // 如果返回的状态码为 200
      if (response.status === 200) {
        // 调用 getList 方法
        this.getList();
      }
    });
  }
  // 导出excel
  handleExport(name: string) {
    const temData = {} as EntityExportReq;
    temData.req = this.queryData.value;
    // 检查变量是否定义
    if (typeof this.api.exportExcel === "undefined") {
      console.error(" api.exportExcel is not undefined.");
      return;
    }
    this.api.exportExcel(temData).then((response) => {
      console.log(response);
      const blob = new Blob([response.data], {
        type: "application/octet-stream"
      });
      saveAs(blob, name + ".xlsx");
    });
  }
  // 导出excel
  handleExportPdf(name: string) {
    const temData = {} as EntityExportReq;
    temData.req = this.queryData.value;
    // 检查变量是否定义
    if (typeof this.api.exportPdf === "undefined") {
      console.error(" api.exportPdf is not undefined.");
      return;
    }
    this.api.exportPdf(temData).then((response) => {
      console.log(response);
      const blob = new Blob([response.data], {
        type: "application/octet-stream"
      });
      saveAs(blob, name + ".xlsx");
    });
  }
  // 下载模板
  downloadTemplate(name: string) {
    // 检查变量是否定义
    if (typeof this.api.downloadTemplate === "undefined") {
      console.error(" api.downloadTemplate is not undefined.");
      return;
    }
    this.api.downloadTemplate().then((response) => {
      console.log(response);
      const blob = new Blob([response.data], {
        type: "application/octet-stream"
      });
      saveAs(blob, name + "_template.xlsx");
    });
  }
  // 导入
  importExcel(val: EntityImportReq): Promise<boolean> {
    const importExcelApi = this.api.importExcel;
    return new Promise((resolve, reject) => {
      if (!val.fileNames) {
        ElMessage({
          message: "请上传文件",
          type: "warning"
        });
        reject(false);
        return;
      }
      // 检查变量是否定义
      if (typeof importExcelApi === "undefined") {
        console.error(" importExcelApi is not undefined.");
        reject(false);
        return;
      }
      importExcelApi(val).then((response) => {
        if (response.status === 200) {
          ElMessage({
            message: response.data,
            type: "success"
          });
          resolve(true);
          this.handleQuery();
        } else {
          ElMessage({
            message: response.data,
            type: "error"
          });
          reject(false);
        }
      });
    });
  }
}
